PC World Komputer 2010 April/PCWorld0410.iso/hity wydania/Ubuntu 9.10 PL/karmelkowy-koliberek-9.10-netbook-remix-PL.iso/casper/filesystem.squashfs/usr/share/pyshared/nevow/i18n.pyc

Python Compiled Bytecode | 2009-03-23 | 8KB | 217 lines

# Source Generated with Decompyle++
# File: in.pyc (Python 2.6)

from zope.interface import implements
from nevow import inevow

def languagesFactory(ctx):
    header = inevow.IRequest(ctx).getHeader('accept-language')
    if header is None:
        return []
    langs = []
    for lang in header.split(','):
        quality = 1
        langs.append((quality, lang))
        if '-' in lang:
            langs.append((quality, lang.split('-')[0]))
            continue
        None if ';' in lang else header is None

    langs.sort((lambda a, b: cmp(b[0], a[0])))
    return [ lang for quality, lang in langs ]


class I18NConfig(object):
    implements(inevow.II18NConfig)

    def __init__(self, domain = None, localeDir = None):
        self.domain = domain
        self.localeDir = localeDir



class PlaceHolder(object):

    def __init__(self, translator, *args, **kwargs):
        self.translator = translator
        self.args = args
        self.kwargs = kwargs
        _mod = kwargs.pop('_mod', None)
        if _mod is None:
            _mod = []

        self.mod = _mod


    def __mod__(self, other):
        kw = { }
        kw.update(self.kwargs)
        kw['_mod'] = self.mod + [
            other]
        return self.__class__(self.translator, *self.args, **kw)


    def __repr__(self):
        args = []
        if self.args:
            args.append('*%r' % (self.args,))

        args.append('translator=%r' % self.translator)
        if self.kwargs:
            args.append('**%r' % self.kwargs)

        s = '%s(%s)' % (self.__class__.__name__, ', '.join(args))
        for mod in self.mod:
            s += ' %% %r' % (mod,)

        return s



def flattenL10n(placeHolder, ctx):
    kw = placeHolder.kwargs

    try:
        languages = inevow.ILanguages(ctx)
    except TypeError:
        pass

    kw = dict(kw)
    kw['languages'] = languages

    try:
        cfg = inevow.II18NConfig(ctx)
    except TypeError:
        pass

    kw = dict(kw)
    if cfg.domain is not None:
        kw['domain'] = cfg.domain

    if cfg.localeDir is not None:
        kw['localeDir'] = cfg.localeDir

    s = placeHolder.translator(*placeHolder.args, **kw)
    for mod in placeHolder.mod:
        s = s % mod

    return s


class Translator(object):
    """
    A gettext-like Translator for Nevow.

    The major difference between this and naive gettext is that with
    Translator, the actual translation is done as part of Nevow's
    flattening process, allowing per-user settings to be retrieved via
    the context.

    @ivar translator: the actual translation function to use.

    @ivar args: positional arguments to pass to translator.

    @ivar kwargs: keyword arguments to pass to translator.

    @ivar gettextFunction: If using the default translator function,
    name of GNU gettext function to wrap. Useful for 'ungettext'.
    """
    translator = None
    args = None
    kwargs = None
    gettextFunction = 'ugettext'

    def _gettextTranslation(self, *args, **kwargs):
        domain = kwargs.pop('domain', None)
        localeDir = kwargs.pop('localeDir', None)
        languages = kwargs.pop('languages', None)
        import gettext as gettext
        translation = gettext.translation(domain = domain, localedir = localeDir, languages = languages, fallback = True)
        fn = getattr(translation, self.gettextFunction)
        return fn(*args, **kwargs)


    def __init__(self, **kwargs):
        '''
        Initialize.

        @keyword translator: the translator function to use.

        @keyword gettextFunction: The GNU gettext function to
        wrap. See class docstring.

        @param kwargs: keyword arguments for the translator function.
        '''
        translator = kwargs.pop('translator', None)
        if translator is not None:
            self.translator = translator

        if self.translator is None:
            self.translator = self._gettextTranslation

        gettextFunction = kwargs.pop('gettextFunction', None)
        if gettextFunction is not None:
            self.gettextFunction = gettextFunction

        self.kwargs = kwargs


    def __call__(self, *args, **kwargs):
        '''
        Translate a string.

        @param args: arguments to pass to translator, usually the
        string to translate, or for things like ungettext two strings
        and a number.

        @param kwargs: keyword arguments for the translator.
        Arguments given here will override the ones given at
        initialization.

        @return: a placeholder that will be translated
        when flattened.

        @rtype: PlaceHolder
        '''
        kw = dict(self.kwargs)
        kw.update(kwargs)
        return PlaceHolder(self.translator, *args, **kw)


_ = Translator()
ungettext = Translator(gettextFunction = 'ungettext')

def render(translator = None):
    """
    Render a localised message.

    >>> from nevow import i18n, rend
    >>> class MyPage(rend.Page):
    ...     render_i18n = i18n.render()

    or, to use a specific domain:

    >>> from nevow import i18n, rend
    >>> _ = i18n.Translator(domain='foo')
    >>> class MyPage(rend.Page):
    ...     render_i18n = i18n.render(translator=_)

    """
    if translator is None:
        translator = _


    def _render(page, ctx, data):
        children = ctx.tag.children
        ctx.tag.clear()
        for child in children:
            if isinstance(child, basestring):
                child = translator(child)

            ctx.tag[child]

        return ctx.tag

    return _render